// 原本方法：暴力法
const handleProductData1 = (dataArr:any[])=>{
    const resultArr:any[] = [];
    for(let row of dataArr){
        const typeIndex = resultArr.findIndex(el=>el['typeId']==row['type_id']);
        if(typeIndex==-1){
            resultArr.push({
                "id": row.id,
                "name": row.type_name,
                "children": [
                    {
                        "id": row.series_id,
                        "name": row.series_name,
                        "children": [ row ],
                    }
                ],
            })
        }else{
            const seriesIndex = resultArr[typeIndex].children.findIndex((el:any)=>el['id']==row['series_id']);
            if(seriesIndex==-1){
                resultArr[typeIndex].children.push({
                    "id": row.series_id,
                    "name": row.series_name,
                    "children": [ row ],
                })
            }else{
                resultArr[typeIndex].children[seriesIndex].children.push(row);
            }
        }
    }

    return resultArr;
}

// 将列表数据转为树形结构数据：使用哈希表优化 数组的findIndex()方法
const handleProductData = (dataArr: any[]) => {
    const resultArr: any[] = [];
    // 哈希表存储：key为typeId和seriesId，value为对应节点的引用
    const typeMap = new Map<string | number, any>();
    const seriesMap = new Map<string | number, any>();

    for (const row of dataArr) {
        const typeId = row.type_id;
        const seriesId = row.series_id;

        // 1. 处理类型节点（最上层）
        let typeNode = typeMap.get(typeId);
        if (!typeNode) {
            typeNode = {
                id: typeId,
                name: row.type_name,
                children: []
            };
            resultArr.push(typeNode);
            typeMap.set(typeId, typeNode); // 存入哈希表，下次直接获取
        }

        // 2. 处理系列节点（中间层）
        let seriesNode = seriesMap.get(seriesId);
        if (!seriesNode) {
            seriesNode = {
                id: seriesId,
                name: row.series_name,
                children: []
            };
            typeNode.children.push(seriesNode);
            seriesMap.set(seriesId, seriesNode); // 存入哈希表，下次直接获取
        }

        // 3. 处理商品节点（最下层）
        seriesNode.children.push(row);
    }

    return resultArr;
};


/**
 * 将数据库返回的列表数据转为树形结构，值得推荐的方法
 */
// 1. 哈希表映射法
function buildTree(data) {
  const map = new Map(); // 存储节点映射：id -> 节点
  const result:any[] = [];

  // 第一次遍历：创建所有节点并存入哈希表, 优化点：可以把构建过程也一起进行，即一边构建哈希表 一边结果集吗？ 不行，因为你不能保证父节点一定在子节点前面     
  data.forEach(item => {
    map.set(item.id, { ...item, children: [] });
  });

  // 第二次遍历：建立父子关系
  data.forEach(item => {
    const node:any = map.get(item.id);
    if (item.parent_id === 0) { // 根节点条件（根据实际业务调整）
      result.push(node);
    } else {
      const parentNode = map.get(item.parent_id);
      if (parentNode) {
        parentNode.children.push(node);
      }
    }
  });

  return result;
}

// 2. 相关工具库：tree-utils：专门处理树形结构的工具库（如 listToTree 方法）。